
int main(void)
{
    deepseek_talk_init();
    deepseek_talk();
}
// /**
//  * @file deepseek_example.c
//  * @brief DeepSeek API 流式对话示例（增强版）
//  * 
//  * 主要改进：
//  * 1. 完善的重试机制与资源管理
//  * 2. 精确的错误分类处理
//  * 3. 安全的中断处理
//  * 4. 友好的交互体验
//  */

//  #include "deepseek_api.h"
//  #include <stdio.h>
//  #include <stdlib.h>
//  #include <unistd.h>
//  #include <signal.h>
//  #include <stdbool.h>
//  #include <time.h>
 
//  // 配置参数
//  #define MAX_RETRIES 3               // 最大重试次数
//  #define BASE_RETRY_DELAY 1          // 基础重试延迟（秒）
//  #define ANIMATION_INTERVAL 200000   // 等待动画刷新间隔（微秒）
 
//  // 全局状态
//  static volatile sig_atomic_t g_interrupted = false;
//  static struct timespec g_request_start_time;
 
//  // 颜色编码日志宏
//  #define DEBUG_LOG(fmt, ...) \
//      printf("\033[36m[DEBUG]\033[0m " fmt "\n", ##__VA_ARGS__)
//  #define ERROR_LOG(fmt, ...) \
//      fprintf(stderr, "\033[31m[ERROR]\033[0m " fmt "\n", ##__VA_ARGS__)
//  #define INFO_LOG(fmt, ...) \
//      printf("\033[32m[INFO]\033[0m " fmt "\n", ##__VA_ARGS__)
 
//  // 信号处理函数
//  /**
//   * @brief 信号处理函数（SIGINT/SIGTERM）
//   * @param sig 接收到的信号编号
//   * 
//   * 功能特性：
//   * 1. 设置原子中断标志 g_interrupted
//   * 2. 线程安全的信号处理（仅使用 async-signal-safe 函数）
//   * 3. 即时响应用户中断请求
//   * 
//   * 注意事项：
//   * - 使用 sig_atomic_t 保证原子操作
//   * - 避免在信号处理函数中进行复杂操作
//   */
//  static void handle_signal(int sig) {
//      g_interrupted = true;  // 设置原子中断标志（保证多线程可见性）
//      fprintf(stderr, "\n[系统] 正在终止请求...\n");  // 用户可见的中断提示
//  }
 
//  // 带超时检测的等待动画
//  /**
//   * @brief 动态等待动画生成器
//   * 
//   * 功能特性：
//   * 1. 使用月相符号实现平滑动画效果
//   * 2. 实时显示已等待时间（毫秒精度）
//   * 3. 非阻塞式屏幕刷新（ANSI转义序列）
//   * 
//   * 实现机制：
//   * - 基于静态变量保存动画帧序列
//   * - 使用单调时钟计算精确耗时
//   * - 通过回车符实现原地刷新
//   */
//  static void show_waiting_animation() {
//      static const char symbols[] = {'🌑', '🌒', '🌓', '🌔', '🌕', '🌖', '🌗', '🌘'}; // 月相动画帧
//      static int counter = 0;         // 动画帧计数器（模8循环）
     
//      // 获取高精度时间（不受系统时间变化影响）
//      struct timespec now;
//      clock_gettime(CLOCK_MONOTONIC, &now);
     
//      // 计算耗时（毫秒为单位）
//      long elapsed = (now.tv_sec - g_request_start_time.tv_sec) * 1000 +
//                    (now.tv_nsec - g_request_start_time.tv_nsec) / 1000000;
     
//      // 输出动态进度条（\r 回到行首，\033[K 清除行尾）
//      printf("\r[系统] 等待响应 %c (已等待 %ldms) ", 
//            symbols[counter++ % 8], elapsed);  // 模8循环月相符号
//      fflush(stdout);  // 强制刷新输出缓冲区
     
//      usleep(ANIMATION_INTERVAL);  // 控制动画刷新频率（200ms）
//  }
 
//  // 增强型流回调（支持中断检测）
//  /**
//   * @brief 流式响应回调函数
//   * @param text 接收到的文本数据指针
//   * @param len 数据长度（字节数）
//   * 
//   * 核心功能：
//   * 1. 实时处理API流式响应数据
//   * 2. 首块数据预处理（清除等待动画）
//   * 3. 安全字符过滤（ASCII 32以上字符）
//   * 4. 响应内容格式化输出
//   * 
//   * 注意事项：
//   * - 使用静态变量保持首块数据状态
//   * - 严格过滤控制字符保证终端安全
//   * - 支持实时响应中断请求
//   */
//  void stream_callback(const char *text, size_t len) {
//      static bool is_first_chunk = true;  // 首块数据标识（跨调用保持状态）
     
//      // 安全过滤：中断/空数据/空指针三种无效情况
//      if (g_interrupted || len == 0 || !text) return;
 
//      // 首块数据处理流程
//      if (is_first_chunk) {
//          printf("\r\033[K"); // ANSI转义序列：\r回到行首，\033[K清除整行
//          INFO_LOG("开始接收响应：");
//          is_first_chunk = false;  // 状态标识更新
//      }
 
//      /* 安全输出过滤：
//       * - 换行符转换为带提示符的新行
//       * - 仅输出可打印字符和制表符
//       * - 过滤所有控制字符（ASCII < 32）
//       */
//      for (size_t i = 0; i < len; ++i) {
//          if (text[i] == '\n') printf("\n  >> ");   // 格式化换行
//          else if (text[i] >= 32 || text[i] == '\t') putchar(text[i]); // 安全字符
//      }
//      fflush(stdout);  // 强制立即输出（避免缓冲区延迟）
//  }
 
//  // 初始化环境
//  /**
//   * @brief 系统环境初始化函数
//   * @param ca_path [out] 证书路径指针的指针
//   * @return bool 初始化是否成功
//   * 
//   * 功能流程：
//   * 1. 注册信号处理器
//   * 2. 检测SSL证书可用性
//   * 3. 初始化HTTP客户端
//   * 4. 设置网络超时参数
//   * 
//   * 安全机制：
//   * - 自动降级非安全模式（证书不可用时）
//   * - 双重HTTP初始化保证兼容性
//   */
//  static bool setup_environment(const char** ca_path) {
//      // 注册中断信号处理器（SIGINT=Ctrl+C, SIGTERM=终止信号）
//      signal(SIGINT, handle_signal);
//      signal(SIGTERM, handle_signal);
 
//      // 检测系统证书路径（Linux标准证书位置）
//      *ca_path = "/etc/ssl/certs/ca-certificates.crt";
//      if (access(*ca_path, R_OK)) {
//          ERROR_LOG("证书不可访问: %s", *ca_path);
//          *ca_path = NULL; // 进入非安全模式
//          ERROR_LOG("警告：已禁用SSL验证！");
//      }
 
//      /* 调试专用初始化（生产环境应移除）
//       * 此处可能用于绕过证书验证进行调试
//       * 注意：实际代码中不应连续调用两次初始化 */
//      HTTP_ClientInit(NULL); // 仅用于调试，生产环境勿用
 
//      // 正式初始化HTTP客户端（根据证书状态决定安全模式）
//      if (!HTTP_ClientInit(*ca_path)) {
//          ERROR_LOG("HTTP初始化失败");
//          return false;
//      }
//      HTTP_SetTimeout(60);  // 设置全局网络超时（单位：秒）
//      return true;
//  }
 
//  // 构造对话内容
//  /**
//   * @brief 对话内容生成器
//   * @param buffer 输出缓冲区（需预先分配内存）
//   * @param size 缓冲区总大小（字节数）
//   * 
//   * 功能说明：
//   * 1. 预定义对话问题列表
//   * 2. 安全填充缓冲区（防溢出）
//   * 3. 自动添加换行分隔符
//   * 
//   * 注意事项：
//   * - 问题列表以 NULL 指针结尾
//   * - 使用 snprintf 保证安全写入
//   * - 支持动态扩展问题列表
//   */
//  static void build_conversation(char* buffer, size_t size) {
//      // 预设问题列表（必须以 NULL 结尾）
//      const char* questions[] = {
//          "你好",          // 示例问题1
//          "你叫什么名字？", // 示例问题2
//          NULL             // 列表终止标记
//      };
     
//      size_t pos = 0;  // 当前写入位置
     
//      // 遍历问题列表填充缓冲区
//      for (int i = 0; questions[i]; ++i) {
//          // 安全写入：返回已写入字节数（包含自动添加的换行符）
//          int written = snprintf(buffer + pos, size - pos, "%s\n", questions[i]);
         
//          // 错误处理：写入失败或缓冲区溢出时终止
//          if (written < 0 || (size_t)written >= size - pos) break;
         
//          pos += written;  // 更新缓冲区写入位置
//      }
//  }
 
//  // 执行请求带重试机制
//  /**
//   * @brief 带指数退避的重试请求执行器
//   * @param api_key DeepSeek API密钥
//   * @param question 要发送的问题内容
//   * @return bool 最终请求是否成功
//   * 
//   * 重试策略：
//   * 1. 指数退避算法：延迟时间 = BASE_DELAY * 2^retries
//   * 2. 最大重试次数限制（MAX_RETRIES）
//   * 3. 实时响应中断请求
//   * 
//   * 监控机制：
//   * - 记录每次请求的精确开始时间
//   * - 实时更新全局中断状态
//   * - 计算精确的等待耗时
//   */
//  static bool execute_request_with_retry(const char* api_key, const char* question) {
//      int retries = 0;        // 当前重试次数
//      bool success = false;   // 请求成功标识
     
//      do {
//          // 记录请求开始时间（用于超时计算）
//          clock_gettime(CLOCK_MONOTONIC, &g_request_start_time);
         
//          // 执行标准API请求（绑定流式回调）
//          success = DS_SendStandardRequest(api_key, question, "deepseek-chat", stream_callback);
         
//          if (success) break;  // 成功则退出重试循环
         
//          // 计算指数退避时间（1, 2, 4 秒...）
//          int delay = BASE_RETRY_DELAY * (1 << retries);  // 位运算实现2的幂次
//          ERROR_LOG("请求失败，%d秒后重试 (%d/%d)...", delay, retries+1, MAX_RETRIES);
         
//          /* 可中断的等待循环：
//           * 1. 每秒检查中断状态
//           * 2. 支持即时响应用户Ctrl+C
//           * 3. 精确控制总等待时间
//           */
//          for (int i = 0; i < delay && !g_interrupted; ++i) {
//              sleep(1);  // 最小等待单位1秒
//          }
//      } while (++retries < MAX_RETRIES && !g_interrupted);  // 双条件控制循环
 
//      // 返回最终状态（成功/重试耗尽/用户中断）
//      return success;
//  }
 
//  /**
//   * @brief 程序主入口函数
//   * 
//   * 执行流程：
//   * 1. 系统环境初始化
//   * 2. API密钥有效性验证
//   * 3. 对话内容构建
//   * 4. 带重试机制的请求执行
//   * 5. 结果状态处理与资源回收
//   * 
//   * 退出码说明：
//   * - EXIT_SUCCESS: 请求成功完成
//   * - EXIT_FAILURE: 请求失败或被中断
//   */
//  int main() {
//      // 第一阶段：环境初始化
//      const char* ca_path;
//      if (!setup_environment(&ca_path)) return EXIT_FAILURE;
//      INFO_LOG("运行环境初始化完成 (%s)", ca_path ? "安全模式" : "非安全模式");
 
//      // 第二阶段：API密钥校验
//      const char* api_key = DEEPSEEK_API_KEY;  // 从编译环境获取密钥
//      if (!api_key || strlen(api_key) < 10) {   // 基础格式校验（长度≥10）
//          ERROR_LOG("无效API密钥");
//          HTTP_ClientCleanup();
//          return EXIT_FAILURE;
//      }
//      DEBUG_LOG("API密钥格式校验通过");
 
//      // 第三阶段：构建请求内容
//      char question[1024] = {0};  // 预分配1KB对话缓冲区
//      build_conversation(question, sizeof(question));
//      DEBUG_LOG("问题内容长度：%zu字节", strlen(question));
 
//      // 第四阶段：执行网络请求
//      INFO_LOG("正在启动请求...");
//      printf("🔄 ");  // 初始化旋转图标
//      fflush(stdout); // 立即显示状态图标
//      bool success = execute_request_with_retry(api_key, question);
 
//      // 第五阶段：处理最终结果
//      printf("\n\n");  // 与响应内容保持间隔
//      if (success) {
//          INFO_LOG("请求成功完成");
//      } else if (g_interrupted) {
//          ERROR_LOG("请求被用户中断");
//      } else {
//          // 显示排错指南（常见问题分类）
//          ERROR_LOG("最终请求失败，建议检查：");
//          ERROR_LOG("1. 网络连接状态");    // 网络层问题
//          ERROR_LOG("2. API密钥权限");    // 认证问题
//          ERROR_LOG("3. 服务状态页：status.deepseek.com"); // 服务端问题
//      }
 
//      // 第六阶段：资源回收
//      HTTP_ClientCleanup();  // 释放HTTP客户端资源
//      INFO_LOG("资源清理完成");
     
//      // 综合状态判断退出码（符合UNIX规范）
//      return g_interrupted ? EXIT_FAILURE : (success ? EXIT_SUCCESS : EXIT_FAILURE);
//  }